import type { Question } from '@/types/exam';

/**
 * Java内存模型与JVM题目（初级10道 + 中级10道 + 高级10道）
 */
export const jvmQuestions: Question[] = [
	// ========== 初级题目（10道） ==========
	{
		id: 6001,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java内存模型与JVM',
		question: 'Java中，对象的内存分配主要在哪个区域？',
		options: [
			{ key: 'A', text: '栈内存' },
			{ key: 'B', text: '堆内存' },
			{ key: 'C', text: '方法区' },
			{ key: 'D', text: '程序计数器' }
		],
		answer: ['B'],
		explanation: '对象的内存分配主要在堆内存中。栈内存存储局部变量和方法调用，方法区存储类信息、常量、静态变量等。'
	},
	{
		id: 6002,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java内存模型与JVM',
		question: 'Java虚拟机（JVM）的主要作用是？',
		options: [
			{ key: 'A', text: '编译Java代码' },
			{ key: 'B', text: '运行Java字节码，实现跨平台' },
			{ key: 'C', text: '编辑Java代码' },
			{ key: 'D', text: '调试Java程序' }
		],
		answer: ['B'],
		explanation: 'JVM的主要作用是运行Java字节码，实现"一次编译，到处运行"的跨平台特性。JVM负责将字节码解释或编译为机器码执行。'
	},
	{
		id: 6003,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: 'Java内存模型与JVM',
		question: 'Java堆内存是线程共享的。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: 'Java堆内存是线程共享的，所有线程都可以访问堆内存中的对象。栈内存是线程私有的，每个线程都有自己的栈。'
	},
	{
		id: 6004,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java内存模型与JVM',
		question: '以下哪个是JVM内存区域的组成部分？',
		options: [
			{ key: 'A', text: '堆、栈、方法区、程序计数器' },
			{ key: 'B', text: 'CPU、内存、硬盘' },
			{ key: 'C', text: '寄存器、缓存' },
			{ key: 'D', text: '只有堆内存' }
		],
		answer: ['A'],
		explanation: 'JVM内存区域主要包括：堆（Heap）、栈（Stack）、方法区（Method Area）、程序计数器（PC Register）、本地方法栈（Native Method Stack）。'
	},
	{
		id: 6005,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java内存模型与JVM',
		question: 'Java中，局部变量存储在哪个内存区域？',
		options: [
			{ key: 'A', text: '堆内存' },
			{ key: 'B', text: '栈内存' },
			{ key: 'C', text: '方法区' },
			{ key: 'D', text: '程序计数器' }
		],
		answer: ['B'],
		explanation: '局部变量存储在栈内存中。栈内存是线程私有的，存储局部变量、方法参数、返回地址等信息。'
	},
	{
		id: 6006,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: 'Java内存模型与JVM',
		question: 'Java中，基本数据类型的变量存储在栈内存中。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: '基本数据类型的变量直接存储在栈内存中。引用类型的变量在栈内存中存储引用地址，实际对象存储在堆内存中。'
	},
	{
		id: 6007,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java内存模型与JVM',
		question: '垃圾回收（GC）主要回收哪个内存区域？',
		options: [
			{ key: 'A', text: '栈内存' },
			{ key: 'B', text: '堆内存' },
			{ key: 'C', text: '程序计数器' },
			{ key: 'D', text: '所有内存区域' }
		],
		answer: ['B'],
		explanation: '垃圾回收主要回收堆内存中不再使用的对象。栈内存随着方法执行结束自动释放，不需要垃圾回收。'
	},
	{
		id: 6008,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java内存模型与JVM',
		question: 'Java中，String常量存储在哪个区域？',
		options: [
			{ key: 'A', text: '堆内存' },
			{ key: 'B', text: '栈内存' },
			{ key: 'C', text: '方法区（常量池）' },
			{ key: 'D', text: '程序计数器' }
		],
		answer: ['C'],
		explanation: 'String常量存储在方法区的常量池中。Java 8+将常量池移到了堆内存的元空间（Metaspace）中。'
	},
	{
		id: 6009,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: 'Java内存模型与JVM',
		question: 'Java栈内存存储的是对象的引用地址。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: '对于引用类型，栈内存存储的是对象的引用地址（指针），实际对象存储在堆内存中。基本类型直接存储值。'
	},
	{
		id: 6010,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java内存模型与JVM',
		question: 'Java堆内存分为哪两个区域？',
		options: [
			{ key: 'A', text: '新生代和老年代' },
			{ key: 'B', text: '栈和方法区' },
			{ key: 'C', text: '本地内存和堆内存' },
			{ key: 'D', text: '常量池和堆' }
		],
		answer: ['A'],
		explanation: 'Java堆内存分为新生代（Young Generation）和老年代（Old Generation）。新生代又分为Eden区、Survivor0、Survivor1三个区域。'
	},

	// ========== 中级题目（10道） ==========
	{
		id: 6011,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java内存模型与JVM',
		question: '新生代垃圾回收算法主要使用？',
		options: [
			{ key: 'A', text: '标记-清除算法' },
			{ key: 'B', text: '复制算法' },
			{ key: 'C', text: '标记-整理算法' },
			{ key: 'D', text: '分代收集算法' }
		],
		answer: ['B'],
		explanation: '新生代主要使用复制算法进行垃圾回收。由于新生代对象生命周期短，复制算法效率高。老年代使用标记-清除或标记-整理算法。'
	},
	{
		id: 6012,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java内存模型与JVM',
		question: 'Java中，以下哪个垃圾回收器适合吞吐量优先的场景？',
		options: [
			{ key: 'A', text: 'Serial GC' },
			{ key: 'B', text: 'Parallel GC' },
			{ key: 'C', text: 'CMS GC' },
			{ key: 'D', text: 'G1 GC' }
		],
		answer: ['B'],
		explanation: 'Parallel GC（并行垃圾回收器）适合吞吐量优先的场景，使用多线程进行垃圾回收，适合后台处理、批处理等对响应时间要求不高的场景。'
	},
	{
		id: 6013,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java内存模型与JVM',
		question: 'Java中，对象什么时候会被移动到老年代？',
		options: [
			{ key: 'A', text: '对象创建时' },
			{ key: 'B', text: '经过多次GC仍然存活，或大对象直接分配' },
			{ key: 'C', text: '对象被引用时' },
			{ key: 'D', text: '对象被销毁时' }
		],
		answer: ['B'],
		explanation: '对象在以下情况会被移动到老年代：1. 经过多次Minor GC仍然存活（默认15次）；2. 大对象直接分配到老年代；3. 动态年龄判断。'
	},
	{
		id: 6014,
		techId: 'java',
		type: 'judge',
		difficulty: 'medium',
		category: 'Java内存模型与JVM',
		question: 'Full GC会回收整个堆内存。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: 'Full GC（Major GC）会回收整个堆内存，包括新生代和老年代，通常会导致应用程序停顿较长时间。'
	},
	{
		id: 6015,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java内存模型与JVM',
		question: 'Java中，以下哪个参数用于设置堆内存大小？',
		options: [
			{ key: 'A', text: '-Xms' },
			{ key: 'B', text: '-Xmx' },
			{ key: 'C', text: 'A和B都可以' },
			{ key: 'D', text: '-Xss' }
		],
		answer: ['C'],
		explanation: '-Xms设置堆内存初始大小，-Xmx设置堆内存最大大小。通常建议将两者设置为相同值，避免动态扩展。'
	},
	{
		id: 6016,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java内存模型与JVM',
		question: 'Java内存模型（JMM）主要解决什么问题？',
		options: [
			{ key: 'A', text: '内存分配问题' },
			{ key: 'B', text: '多线程环境下的内存可见性和有序性' },
			{ key: 'C', text: '垃圾回收问题' },
			{ key: 'D', text: '类加载问题' }
		],
		answer: ['B'],
		explanation: 'Java内存模型（JMM）定义了多线程环境下，变量如何从主内存读取到工作内存，以及如何从工作内存写回主内存，解决了可见性、有序性和原子性问题。'
	},
	{
		id: 6017,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java内存模型与JVM',
		question: 'volatile关键字的作用不包括？',
		options: [
			{ key: 'A', text: '保证可见性' },
			{ key: 'B', text: '保证有序性' },
			{ key: 'C', text: '保证原子性' },
			{ key: 'D', text: '禁止指令重排序' }
		],
		answer: ['C'],
		explanation: 'volatile关键字保证变量的可见性和有序性，禁止指令重排序，但不保证原子性。对于复合操作（如i++），仍然需要synchronized或原子类来保证原子性。'
	},
	{
		id: 6018,
		techId: 'java',
		type: 'multiple',
		difficulty: 'medium',
		category: 'Java内存模型与JVM',
		question: '以下哪些是JVM的垃圾回收算法？',
		options: [
			{ key: 'A', text: '标记-清除算法' },
			{ key: 'B', text: '复制算法' },
			{ key: 'C', text: '标记-整理算法' },
			{ key: 'D', text: '分代收集算法' }
		],
		answer: ['A', 'B', 'C', 'D'],
		explanation: 'JVM的垃圾回收算法包括：标记-清除（有内存碎片）、复制算法（适合新生代）、标记-整理（适合老年代）、分代收集（结合多种算法）。'
	},
	{
		id: 6019,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java内存模型与JVM',
		question: 'Java中，以下哪个会导致内存泄漏？',
		options: [
			{ key: 'A', text: '对象被正确引用' },
			{ key: 'B', text: '静态集合持有对象引用，未及时清理' },
			{ key: 'C', text: '对象正常被垃圾回收' },
			{ key: 'D', text: '使用局部变量' }
		],
		answer: ['B'],
		explanation: '内存泄漏是指对象已经不再使用，但由于某种原因无法被垃圾回收。常见原因包括：静态集合持有引用、监听器未移除、内部类持有外部类引用等。'
	},
	{
		id: 6020,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java内存模型与JVM',
		question: 'G1垃圾回收器的特点不包括？',
		options: [
			{ key: 'A', text: '适合大堆内存' },
			{ key: 'B', text: '可预测的停顿时间' },
			{ key: 'C', text: '只适合小堆内存' },
			{ key: 'D', text: '并发收集' }
		],
		answer: ['C'],
		explanation: 'G1垃圾回收器适合大堆内存（6GB以上），具有可预测的停顿时间，支持并发收集。它将堆内存分为多个Region，优先回收垃圾最多的区域。'
	},

	// ========== 高级题目（10道） ==========
	{
		id: 6021,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java内存模型与JVM',
		question: 'Java中，以下哪个关于synchronized的说法是正确的？',
		options: [
			{ key: 'A', text: 'synchronized只保证原子性' },
			{ key: 'B', text: 'synchronized保证原子性、可见性和有序性' },
			{ key: 'C', text: 'synchronized只保证可见性' },
			{ key: 'D', text: 'synchronized只保证有序性' }
		],
		answer: ['B'],
		explanation: 'synchronized关键字保证原子性（互斥访问）、可见性（释放锁前将变量刷新到主内存）、有序性（禁止指令重排序）。'
	},
	{
		id: 6022,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java内存模型与JVM',
		question: 'Java中，以下哪个会导致线程安全问题？',
		options: [
			{ key: 'A', text: '多个线程访问共享变量，且操作不是原子性的' },
			{ key: 'B', text: '多个线程访问局部变量' },
			{ key: 'C', text: '单线程访问共享变量' },
			{ key: 'D', text: '使用final变量' }
		],
		answer: ['A'],
		explanation: '线程安全问题通常发生在多个线程访问共享变量，且操作不是原子性的情况下。局部变量是线程私有的，不存在线程安全问题。'
	},
	{
		id: 6023,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java内存模型与JVM',
		question: 'Java中，以下哪个关于类加载的说法是正确的？',
		options: [
			{ key: 'A', text: '类加载器采用双亲委派机制' },
			{ key: 'B', text: '类可以被加载多次' },
			{ key: 'C', text: '类加载器没有层次结构' },
			{ key: 'D', text: '类加载器可以随意加载类' }
		],
		answer: ['A'],
		explanation: 'Java类加载器采用双亲委派机制，先委托父类加载器加载，只有父类加载器无法加载时，才由自己加载。这样可以保证类的唯一性和安全性。'
	},
	{
		id: 6024,
		techId: 'java',
		type: 'multiple',
		difficulty: 'hard',
		category: 'Java内存模型与JVM',
		question: '以下哪些是JVM的类加载器？',
		options: [
			{ key: 'A', text: 'Bootstrap ClassLoader' },
			{ key: 'B', text: 'Extension ClassLoader' },
			{ key: 'C', text: 'Application ClassLoader' },
			{ key: 'D', text: 'Custom ClassLoader' }
		],
		answer: ['A', 'B', 'C', 'D'],
		explanation: 'JVM的类加载器包括：Bootstrap（启动类加载器，加载核心类库）、Extension（扩展类加载器）、Application（应用程序类加载器）、Custom（自定义类加载器）。'
	},
	{
		id: 6025,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java内存模型与JVM',
		question: 'Java中，以下哪个关于内存屏障的说法是正确的？',
		options: [
			{ key: 'A', text: '内存屏障保证指令顺序执行' },
			{ key: 'B', text: '内存屏障保证内存可见性' },
			{ key: 'C', text: '内存屏障保证原子性' },
			{ key: 'D', text: 'A和B都对' }
		],
		answer: ['D'],
		explanation: '内存屏障（Memory Barrier）保证指令顺序执行和内存可见性。它禁止指令重排序，确保屏障前的操作对屏障后的操作可见。'
	},
	{
		id: 6026,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java内存模型与JVM',
		question: 'Java中，以下哪个关于逃逸分析的说法是正确的？',
		options: [
			{ key: 'A', text: '逃逸分析可以优化对象分配' },
			{ key: 'B', text: '逃逸分析可以栈上分配对象' },
			{ key: 'C', text: '逃逸分析可以减少垃圾回收压力' },
			{ key: 'D', text: '以上都对' }
		],
		answer: ['D'],
		explanation: '逃逸分析是JVM的优化技术，分析对象的作用域，如果对象不会逃逸出方法，可以在栈上分配，减少堆内存分配和垃圾回收压力。'
	},
	{
		id: 6027,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java内存模型与JVM',
		question: 'Java中，以下哪个关于JIT编译的说法是错误的？',
		options: [
			{ key: 'A', text: 'JIT编译将热点代码编译为机器码' },
			{ key: 'B', text: 'JIT编译可以提高执行效率' },
			{ key: 'C', text: 'JIT编译在运行时进行' },
			{ key: 'D', text: 'JIT编译在编译时进行' }
		],
		answer: ['D'],
		explanation: 'JIT（Just-In-Time）编译是在运行时进行的，将热点代码（频繁执行的代码）编译为本地机器码，提高执行效率。'
	},
	{
		id: 6028,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java内存模型与JVM',
		question: 'Java中，以下哪个关于方法区的说法是正确的？',
		options: [
			{ key: 'A', text: 'Java 8+方法区由元空间（Metaspace）实现' },
			{ key: 'B', text: '方法区存储类信息、常量、静态变量' },
			{ key: 'C', text: '方法区在堆内存之外' },
			{ key: 'D', text: '以上都对' }
		],
		answer: ['D'],
		explanation: '方法区存储类信息、常量、静态变量等。Java 8+使用元空间（Metaspace）实现方法区，使用本地内存而不是堆内存，可以动态扩展。'
	},
	{
		id: 6029,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java内存模型与JVM',
		question: 'Java中，以下哪个关于对象创建的流程是正确的？',
		options: [
			{ key: 'A', text: '类加载 -> 分配内存 -> 初始化零值 -> 设置对象头 -> 执行构造函数' },
			{ key: 'B', text: '分配内存 -> 类加载 -> 初始化零值 -> 设置对象头 -> 执行构造函数' },
			{ key: 'C', text: '执行构造函数 -> 分配内存 -> 类加载' },
			{ key: 'D', text: '直接创建对象' }
		],
		answer: ['A'],
		explanation: '对象创建流程：1. 类加载检查；2. 分配内存（堆内存）；3. 初始化零值；4. 设置对象头（类信息、哈希码、GC分代年龄等）；5. 执行构造函数。'
	},
	{
		id: 6030,
		techId: 'java',
		type: 'multiple',
		difficulty: 'hard',
		category: 'Java内存模型与JVM',
		question: '以下哪些是JVM调优的参数？',
		options: [
			{ key: 'A', text: '-Xms（堆内存初始大小）' },
			{ key: 'B', text: '-Xmx（堆内存最大大小）' },
			{ key: 'C', text: '-Xss（栈内存大小）' },
			{ key: 'D', text: '-XX:MetaspaceSize（元空间大小）' }
		],
		answer: ['A', 'B', 'C', 'D'],
		explanation: 'JVM调优参数包括：-Xms/-Xmx（堆内存）、-Xss（栈内存）、-XX:MetaspaceSize（元空间）、-XX:NewRatio（新生代比例）、-XX:SurvivorRatio（Survivor比例）等。'
	}
];

